#include <vector>
#include <unordered_map>
#include <unordered_set>
#include <iostream>

using namespace std;

class Twitter
{
public:
    Twitter()
    {
    }

    void postTweet(int userId, int tweetId)
    {
        checkNewUser(userId);
        userPosts[userId].push_back(tweetId);
        postsId[tweetId] = ++id;
    }

    vector<int> getNewsFeed(int userId)
    {
        vector<int> result;
        vector<int> visibleUsers;
        visibleUsers.push_back(userId);
        for (auto followedUserId : userFollows[userId])
        {
            visibleUsers.push_back(followedUserId);
        }
        int userCount = visibleUsers.size();
        using iterator = decltype(userPosts[visibleUsers[0]].rbegin());
        vector<iterator> latestPosts;
        for (int i = 0; i < userCount; ++i)
        {
            latestPosts.push_back(userPosts[visibleUsers[i]].rbegin());
        }
        for (int i = 0; i < 10; ++i)
        {
            // iterator &latestPost = latestPosts[0]; // 不要直接引用容器元素，可能会有奇奇怪怪的错误
            int lastestPostUser = 0;
            int latestPostId = 0;
            bool foundPost = false;
            for (int j = 0; j < userCount; ++j)
            {
                if (latestPosts[j] == userPosts[visibleUsers[j]].rend())
                {
                    continue;
                }
                if (postsId[*latestPosts[j]] > latestPostId)
                {
                    latestPostId = postsId[*latestPosts[j]];
                    lastestPostUser = j;
                    foundPost = true;
                }
            }
            if (foundPost)
            {
                result.push_back(*latestPosts[lastestPostUser]);
                ++latestPosts[lastestPostUser];
            }
            else
            {
                break;
            }
        }
        return result;
    }

    void follow(int followerId, int followeeId)
    {
        checkNewUser(followerId);
        checkNewUser(followeeId);
        userFollows[followerId].insert(followeeId);
    }

    void unfollow(int followerId, int followeeId)
    {
        userFollows[followerId].erase(followeeId);
    }

private:
    unordered_map<int, vector<int>> userPosts;
    unordered_map<int, unordered_set<int>> userFollows;
    unordered_set<int> users;
    unordered_map<int, int> postsId;
    int id = 0;

    void checkNewUser(int userId)
    {
        if (!users.count(userId))
        {
            users.insert(userId);
            userPosts[userId] = vector<int>();
            userFollows[userId] = unordered_set<int>();
        }
    }
};

/**
 * Your Twitter object will be instantiated and called as such:
 * Twitter* obj = new Twitter();
 * obj->postTweet(userId,tweetId);
 * vector<int> param_2 = obj->getNewsFeed(userId);
 * obj->follow(followerId,followeeId);
 * obj->unfollow(followerId,followeeId);
 */

int main()
{

    Twitter twitter = Twitter();
    twitter.postTweet(1, 5);             // 用户 1 发送了一条新推文 (用户 id = 1, 推文 id = 5)
    auto posts = twitter.getNewsFeed(1); // 用户 1 的获取推文应当返回一个列表，其中包含一个 id 为 5 的推文
    twitter.follow(1, 2);           // 用户 1 关注了用户 2
    twitter.postTweet(2, 6);        // 用户 2 发送了一个新推文 (推文 id = 6)
    posts = twitter.getNewsFeed(1); // 用户 1 的获取推文应当返回一个列表，其中包含两个推文，id 分别为 -> [6, 5] 。推文 id 6 应当在推文 id 5 之前，因为它是在 5 之后发送的
    twitter.unfollow(1, 2);         // 用户 1 取消关注了用户 2
    posts = twitter.getNewsFeed(1); // 用户 1 获取推文应当返回一个列表，其中包含一个 id 为 5 的推文。因为用户 1 已经不再关注用户 2

    return 0;
}